// 旋转数组
// 1、pop和unshift
function roateArr1 (arr, k) {
    let step = k % arr.length;
    while(k) {
        let last = arr.pop();
        arr.unshift(last);
        k--;
    };
    return arr;
}
// console.log(roateArr1([1, 2, 3, 4, 5, 6], 1));

// 2、slice
function roateArr2(arr, k) {
    let step = k % arr.length;
    let tem1 = arr.slice(-step);
    let temp2 = arr.slice(0, arr.length - step);
    return tem1.concat(temp2);
}
// console.log(roateArr2([1, 2, 3, 4, 5, 6], 2))

// 3 splice方法
function roateArr3(arr, k) {
    let step = k % arr.length;
    return arr.splice(-step).concat(arr);
}
// console.log(roateArr3([1, 2, 3, 4, 5], 4))


// ---------------------------------------------------------------------
// 请找出1-10000中的对称数字

// 构造数据列表的几种方式
let numsArr = [...Array(10000).keys()].map(i => i + 1);
let numsArr2 = Array.from({length: 10000}, (v, i) => i + 1);
let numsArr3 = new Array(10000).fill('').map((v, i) => i + 1)
// console.log(numsArr3);


// 1、revere倒转对比
function getLvLNums1(arr) {
    return arr.filter((item, i) => item.toString().split('').reverse().join('') == item)
};

// console.log(getLvLNums1(numsArr))


// 2、数学规律构造
// 1、2、3、...9
// 11、22...99
// 101、111、121...191、202...292、909...999
// 1001、1111、1221....2002、2112.....9009、9119...9999
function getLvLNums2() {
    let res  = [];
    let i = 1;
    for(;i <= 9; i++) {
        res.push(i);
        res.push(11 * i);
        for(let j = 0; j <=9; j++) {
            res.push(101 * i + 10 * j);
            res.push(1001 * i + 110 * j);
        }
    }
    return res.sort((a, b) => a - b)
}
// console.log(getLvLNums2())


// ---------------------------------------------------------------------

//  给定一个数组将该数组的0项放到最后

// 1、filter筛选思路

let testArr = [1, 0, 3, 0, 0, 99, 0];

function afterZeroFn1(arr) {
    return arr.filter(item => +item).concat(Array(arr.length - arr.filter(item => +item).length).fill('0').map(v => +v))
};
// console.log(afterZeroFn1(testArr));


// 2、push和splice思路
// 注意点: 需要一个变量来动态减少循环的次数
function afterZeroFn2(arr) {
    let i = 0;
    let num = 0;
    for(;i < arr.length - num; i++) {
        if (arr[i] === 0) {
            arr.splice(i, 1);
            arr.push(0);
            num ++;
            i--;
        }
    }
    return arr;
}
// console.log(afterZeroFn2(testArr));

// 3、排序算法是思路--双指针思想
function afterZeroFn3(arr) {
    let point1 = 0;
    let i = 0;
    for(;i < arr.length; i++) {
        if (arr[i] === 0 && arr[point1] !== 0) {
            point1 = i;
        } else {
            if (point1 < i && arr[i] != 0 && arr[point1] === 0) {
                let temp = arr[i];
                arr[point1] = temp;
                arr[i] = 0;
                point1 = i;
            }
        }
    }
    return arr;
}
// console.log(afterZeroFn3(testArr));
// ---------------------------------------------------------------------




// setTimeout第三个参数
for(let i = 0; i < 3; i++) {
    setTimeout(_ => {
        // console.log(i)
    }, 0)
}

// setTimeout(_ => {
//     console.log('after...')
// }, 1000, setTimeout(() => {
//     console.log('before...')
// }, 0))



// ---------------------------------------------------------------------

// 实现一个方法可以将传入的数字逆序字符串形式输出
// 例子：123 =》 ‘321’

// 1、数组reserve思路
let str = '12345';
function strReverse1(str) {
    return str.toString().split('').reverse().join('');
};
// console.log('strReverse1=>', strReverse1(str));

// 2、字符串递归截取思路
// 递归需要有一个合适的结束时机
function strReverse2(str) {
    let temp = str + '';
    if (temp.length === 1) return temp;
    return temp.substring(temp.length - 1) + strReverse2(temp.substring(0, temp.length - 1));
}
// console.log('strReverse2=>', strReverse2(str));


// 3、 数学取值思想(递归思想)
// 12345 -----> 12345 % 10 = 5   Math.floor(12345 / 10) = 1234
// 1234 ----> 1234 % 10 = 4 Math.floor(1234 / 10) = 123
// 123 ----> 123 % 10 = 3 Math.floor(123 / 10) = 12
// 12 ----> 12 % 10 = 2 Math.floor(12 / 10) = 1
// 1 ----> 1 % 10 = 1 Math.floor(1 / 10) = 0

function strReverse3(str) {
    temp = Math.floor(str / 10);
    if (temp == 0) return str % 10;
    return str % 10 + '' + strReverse3(temp);
}
// console.log('strReverse3=>', strReverse3(str));



// ---------------------------------------------------------------------
// 1、foreach进行的循环,每一个循环都是独立的作用域,是并行的,是互不影响的
// 2、将循环变成串行,要么变成一个作用域的同步形式(for循环),要么使用promise的then进行串行


// 观察下面代码的输出
let getOut = function(n) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(n)
    }, 1000)
    })
};

let testArr1 = [1, 2, 3];
// testArr1.forEach(async (num, i) => {
//     let res = await getOut(num);
//     console.log(res);// 将会隔一秒同时输出 1 2 3
// });

// 上面代码的本质是这样:
// (async function(num) {
//     let res = await getOut(num);
//     console.log(res);
// })(num) // num = 1
// (async function(num) {
//     let res = await getOut(num);
//     console.log(res);
// })(num) // num = 2
// (async function(num) {
//     let res = await getOut(num);
//     console.log(res);
// })(num) // num = 3


// 改成每隔一秒分别输出 1 2 3
// 1.for循环变成一个作用域下的同步代码
async function outputFn1() {
    for(let i = 0; i < testArr1.length; i++) {
        let res = await getOut(testArr1[i]);
        console.log(res)
    }
}

// outputFn1();

async function outputFn2() {
    for(item of testArr1) {
        let res = await getOut(item);
        console.log(res)
    }
}
// outputFn2();

// 2.通过promise.then来调用实现串行
function outputFn3(arr) {
    let count = 0;
    function inFn() {
        if (count >= testArr1.length) return;
        let pro = Promise.resolve();
        pro.then(async res => {
            let result = await getOut(arr[count]);
            console.log(result);
            count++;
            inFn();
        })
    }
    inFn()
}

// outputFn3(testArr1)



// 写一个myInterval(fn,a , b, n)
// 每次间隔a, a+b, a+2b...a+nb的时间执行fn函数，执行n次欧关闭定时器

function myInterval(fn, a, b, n) {
    let _a = a;
    let _b = b;
    let _n = n;
    let count = 0;
    let _fn = fn;
    function inFn() {
        let time = _a + count * _b;
        console.log('time=>', time)
        if (count >= _n) {
            return;
        }
        setTimeout(_ => {
            _fn();
            count++;
            inFn();
        }, time)
    }
    inFn();
}

// myInterval(function(){
//     console.log('myInterval....');
// }, 1000, 2000, 3);// 1s  3s 5s 7s


// 实现一个将rgb转成16进制的方法
// 例子：rgb(255, 255, 255) ==> #ffffff

// 思路分析
// 1、通过正则将rgb(255, 255, 255)中的颜色值提取出来
// 2、将数字进行16进制转化
//         2.1 通过toString()方法进行进制转化
//         2.2 必须注意大于16的数字转化成16精致前面是不需要补0 的

let testRGB = 'rgb(255, 255, 2)';

function TranfromColor() {
    this.originColor = '';
    this.colorArr = [];
    this.result = '#';
    // rgb(255, 255, 255)
    // this.colorReg = /\d+/g;
    this.colorReg = /^(rgb|RGB)\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\s*$/;
    this.get16Color = function(rgbColor) {
        this.originColor = rgbColor;
        if (!this.originColor) return;
        this.getColorArr(this.originColor).forEach((item, idx) => {
            // this.result += ('0' + Number(item).toString(16)).substr(-2);
            this.result += (Number(item) > 16 ? '' : '0') + Number(item).toString(16);
            // this.result += ('' + Number(item).toString(16)).padStart(2, 0);
        });
        return this.result;
    };
    this.getColorArr = (originColor) => {
        let matchRes = originColor.match(this.colorReg);
        if (!matchRes) return;
        // console.log(matchRes, matchRes[0], matchRes[1], matchRes[2]);
        matchRes[2] && this.colorArr.push(matchRes[2]);
        matchRes[3] && this.colorArr.push(matchRes[3]);
        matchRes[4] && this.colorArr.push(matchRes[4]);
        [...Array(3).keys()].forEach((item, indx) => {
            +this.colorArr[item] > 255 && (this.colorArr[item] = '255')
        });
        return this.colorArr;
    }
}

let tranfromColor = new TranfromColor();
let color16 = tranfromColor.get16Color(testRGB);
console.log(color16)